home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 001 / pibt3sp1.arc / KINIT.PAS < prev    next >
Pascal/Delphi Source File  |  1985-10-04  |  7KB  |  152 lines
  1. (*----------------------------------------------------------------------*)
  2. (*              Kermit_Tab --- Expand tabs in Kermit packets            *)
  3. (*----------------------------------------------------------------------*)
  4.  
  5. FUNCTION Kermit_Tab( Spaces : INTEGER ) : AnyStr;
  6.  
  7. (*----------------------------------------------------------------------*)
  8. (*                                                                      *)
  9. (*     Function:   Kermit_Tab                                           *)
  10. (*                                                                      *)
  11. (*     Purpose:    Expand tabs in Kermit packets.                       *)
  12. (*                                                                      *)
  13. (*     Calling Sequence:                                                *)
  14. (*                                                                      *)
  15. (*        ExpString := Kermit_Tab( Spaces : INTEGER ) : AnyStr;         *)
  16. (*                                                                      *)
  17. (*----------------------------------------------------------------------*)
  18.  
  19. BEGIN (* Kermit_Tab *)
  20.  
  21.    Kermit_Tab := Dupl( ' ' , Spaces );
  22.  
  23. END   (* Kermit_Tab *);
  24.  
  25. (*----------------------------------------------------------------------*)
  26. (*         Kermit_Ctrl --- Convert control character to letter          *)
  27. (*----------------------------------------------------------------------*)
  28.  
  29. FUNCTION Kermit_Ctrl( Ch : CHAR ) : CHAR;
  30.  
  31. (*----------------------------------------------------------------------*)
  32. (*                                                                      *)
  33. (*     Function:   Kermit_Ctrl                                          *)
  34. (*                                                                      *)
  35. (*     Purpose:    Convert control character to letter                  *)
  36. (*                                                                      *)
  37. (*     Calling Sequence:                                                *)
  38. (*                                                                      *)
  39. (*        CtrlCh := Kermit_Ctrl( Ch : CHAR ) : CHAR;                    *)
  40. (*                                                                      *)
  41. (*----------------------------------------------------------------------*)
  42.  
  43. BEGIN (* Kermit_Ctrl *)
  44.  
  45.    Kermit_Ctrl := CHR( ORD( Ch ) XOR $40 );
  46.  
  47. END   (* Kermit_Ctrl *);
  48.  
  49.  
  50. (*----------------------------------------------------------------------*)
  51. (*         Kermit_Char40 --- Add octal 40 to a character                *)
  52. (*----------------------------------------------------------------------*)
  53.  
  54. FUNCTION Kermit_Char40( Number : INTEGER ) : CHAR;
  55.  
  56. (*----------------------------------------------------------------------*)
  57. (*                                                                      *)
  58. (*     Function:   Kermit_Char40                                        *)
  59. (*                                                                      *)
  60. (*     Purpose:    Add octal 40 to a character                          *)
  61. (*                                                                      *)
  62. (*     Calling Sequence:                                                *)
  63. (*                                                                      *)
  64. (*        Ch40 := Kermit_Char40( Number : INTEGER ) : CHAR;             *)
  65. (*                                                                      *)
  66. (*----------------------------------------------------------------------*)
  67.  
  68. VAR
  69.    Byte_Number : BYTE;
  70.  
  71. BEGIN (* Kermit_Char40 *)
  72.  
  73.    Byte_Number := Number;
  74.  
  75.    Kermit_Char40 := CHR( Byte_Number + 32 );
  76.  
  77. END   (* Kermit_Char40 *);
  78.  
  79. (*----------------------------------------------------------------------*)
  80. (*         Kermit_UnChar --- Add octal 40 to a character                *)
  81. (*----------------------------------------------------------------------*)
  82.  
  83. FUNCTION Kermit_UnChar( Ch : CHAR ) : INTEGER;
  84.  
  85. (*----------------------------------------------------------------------*)
  86. (*                                                                      *)
  87. (*     Function:   Kermit_UnChar                                        *)
  88. (*                                                                      *)
  89. (*     Purpose:    Convert letter to control character                  *)
  90. (*                                                                      *)
  91. (*     Calling Sequence:                                                *)
  92. (*                                                                      *)
  93. (*        Ch40 := Kermit_UnChar( Ch : CHAR ) : INTEGER;                 *)
  94. (*                                                                      *)
  95. (*----------------------------------------------------------------------*)
  96.  
  97. BEGIN (* Kermit_UnChar *)
  98.  
  99.    Kermit_UnChar := ORD( Ch ) - 32;
  100.  
  101. END   (* Kermit_UnChar *);
  102.  
  103. (*----------------------------------------------------------------------*)
  104. (*              Kermit_Init --- Initialize global Kermit variables      *)
  105. (*----------------------------------------------------------------------*)
  106.  
  107. PROCEDURE Kermit_Init;
  108.  
  109. (*----------------------------------------------------------------------*)
  110. (*                                                                      *)
  111. (*     Procedure:  Kermit_Init                                          *)
  112. (*                                                                      *)
  113. (*     Purpose:    Initializes global Kermit variables                  *)
  114. (*                                                                      *)
  115. (*     Calling Sequence:                                                *)
  116. (*                                                                      *)
  117. (*        Kermit_Init;                                                  *)
  118. (*                                                                      *)
  119. (*----------------------------------------------------------------------*)
  120.  
  121. BEGIN (* Kermit_Init *)
  122.                                    (* Ascii is default if not given *)
  123.  
  124.    IF Kermit_File_Type_Var = Kermit_None THEN
  125.       Kermit_File_Type_Var := Kermit_Ascii;
  126.  
  127.                                    (* Default checksum method *)
  128.    His_Chk_Type          := '1';
  129.  
  130.                                    (* Initial packet size *)
  131.  
  132.    Kermit_Packet_Size   := Kermit_Init_Packet_Size;
  133.  
  134.                                    (* Don't send padding unless requested *)
  135.    My_Pad_Num    := 0;
  136.    My_Pad_Char   := Kermit_Pad_Char;
  137.  
  138.                                    (* Send a CR to start with *)
  139.  
  140.    Send_EOL      := ORD( Kermit_EOL );
  141.  
  142.                                    (* No 8-bit quoting unless binary with parity *)
  143.    Quoting       := FALSE;
  144.                                    (* Time out *)
  145.    His_TimeOut   := Kermit_TimeOut;
  146.  
  147.                                    (* 8-but quote *)
  148.  
  149.    His_Quote_8_Char := Kermit_Quote_8_Char;
  150.  
  151. END   (* Kermit_Init *);
  152.